package com.gxa.dr2.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.gxa.dr2.dto.LayDTO;
import com.gxa.dr2.dto.Response;
import com.gxa.dr2.dto.ResultDTO;
import com.gxa.dr2.mapper.EmplMapper;
import com.gxa.dr2.mapper.EmplRoleMapper;
import com.gxa.dr2.param.MyParam;
import com.gxa.dr2.pojo.Empl;
import com.gxa.dr2.pojo.EmplRole;
import com.gxa.dr2.service.EmplService;
import com.gxa.dr2.util.MD5Util;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.List;

@Service
public class EmplServiceImpl implements EmplService {

    @Resource
    private EmplMapper emplMapper;
    @Resource
    private EmplRoleMapper emplRoleMapper;
    /**
     * 员工的列表数据
     * @return
     */
    @Override
    public LayDTO list(MyParam param) {
        // 分页
        PageHelper.startPage(param.getPage(), param.getLimit());
        List<Empl> empls = emplMapper.findByParam(param);
        // 将结果集包装成pageInfo
        PageInfo<Empl> pageInfo = new PageInfo<>(empls);

        return Response.success(pageInfo.getTotal(), pageInfo.getList());
    }

    /**
     * 添加员工
     *
     * @param empl    ： 员工对象
     * @param roleIds ： 角色的ID数组
     * @return
     */
    @Override
    @Transactional(rollbackFor = Throwable.class)
    public ResultDTO add(Empl empl, Integer[] roleIds) {
        // 处理员工编号  EMPL_1003 =》 EMPL_1004
        empl.setEmplCode(getNewEmplCode());
        // 处理密码 =》 111111
        empl.setEmplPwd(MD5Util.MD55("111111"));
        // 处理创建时间
        empl.setCreateTime(new Timestamp(System.currentTimeMillis()));
        // 添加数据
        this.emplMapper.save(empl);
        // 处理关系表数据
        for (Integer roleId : roleIds) {
            this.emplRoleMapper.save(new EmplRole(empl.getEmplId(), roleId));
        }
        return Response.success("添加成功！");
    }

    /**
     * 修改状态
     *
     * @param empl
     * @return
     */

    @Override
    public ResultDTO changeStatus(Empl empl) {
        // 处理更新时间
        empl.setUpdateTime(new Timestamp(System.currentTimeMillis()));
        this.emplMapper.update(empl);
        return Response.success("更新成功！");
    }

    /**
     * 修改电话
     *
     * @param empl
     * @return
     */
    @Override
    public ResultDTO changePhone(Empl empl, Long phone, HttpSession session) {
        empl.setEmplId((Integer) session.getAttribute("emplId"));
        empl.setEmplPhone(phone);
        this.emplMapper.update(empl);
        session.setAttribute("phone", emplMapper.findById(empl.getEmplId()).getEmplPhone());
        return Response.success("修改电话成功");
    }

    /**
     * 修改登录 ID
     *
     * @param empl
     * @return
     */

    @Override
    public ResultDTO changeEmplCode(Empl empl, String emplCode, HttpSession session) {
        // 获取数据库的 登录员工信息
        empl.setEmplId((Integer) session.getAttribute("emplId"));
        empl.setEmplCode(emplCode);
        Empl dbEmpl = emplMapper.findById(empl.getEmplId());

        // 判读修改后的登录ID是不是已经存在，如果存在，则直接提示返回，否则更新 登录ID
        if(dbEmpl.getEmplCode() != emplCode && isExistEmlCode(emplCode)){
            return Response.error(500,emplCode+" 已经存在了");
        }

        this.emplMapper.update(empl);
        session.setAttribute("emplCode", emplMapper.findById(empl.getEmplId()).getEmplCode());
        return Response.success("修改登录ID成功");
    }

    public ResultDTO changePWD(HttpSession session, String pwd, String newPWD, String newPWD2){
        Empl empl = new Empl();
        empl.setEmplCode((String) session.getAttribute("emplCode"));
        empl.setEmplId((Integer) session.getAttribute("emplId"));
        Empl dbEmpl = emplMapper.findByCode(empl); // empl {emplCode, pwd}
        if (!dbEmpl.getEmplPwd().equals(MD5Util.MD55(pwd))) {
            return Response.error(1001, "密码错误！");
        }
        if(!newPWD.equals(newPWD2)){
            return Response.error(500, "两次密码不一样！！！");
        }

        if(dbEmpl.getEmplPwd().equals(MD5Util.MD55(newPWD))){
           return Response.error(1001,"新密码不能是原始密码！！！" );
        }

        // 更新密码
        empl.setEmplPwd(MD5Util.MD55(newPWD));
        this.emplMapper.update(empl);
        return Response.success("密码修改成功");
    }

    /**
     * 通过 EmplCode 查询员工
     * @param emplCode
     * @return
     */
    public boolean isExistEmlCode(String emplCode){
        Empl empl = new Empl();
        empl.setEmplCode(emplCode);
        Empl empl1 = emplMapper.findByCode(empl);
        return empl1 != null;
    }


    /**
     * 获取最新的code
     * @return
     */
    private String getNewEmplCode(){
        Empl lastEmpl = this.emplMapper.findLastEmpl();
        String oldCode = lastEmpl.getEmplCode();
        // 获取数字部分 EMPL_1004  => 1004
        Integer code = Integer.valueOf(oldCode.substring(5));
        // 自增
        code++;
        return "EMPL_"+code;
    }


    /**
     * 获取员工的详情
     *
     * @param emplId
     * @return
     */
    @Override
    public ResultDTO detail(Integer emplId) {

        Empl empl = this.emplMapper.findById(emplId);
        return Response.success(empl);
    }

    /**
     * 员工的编辑
     *
     * @param empl    : 员工对象
     * @param roleIds ： 角色ID数组
     * @return
     */
    @Override
    @Transactional(rollbackFor = Throwable.class)
    public ResultDTO edit(Empl empl, Integer[] roleIds) {
        // 先处理更新时间
        empl.setUpdateTime(new Timestamp(System.currentTimeMillis()));
        // 更新员工
        this.emplMapper.update(empl);

        // 处理关系表的数据
        // 先删除原有的关系数据
        this.emplRoleMapper.deleteByEmplId(empl.getEmplId());
        // 再添加新的关系数据
        for (Integer roleId : roleIds) {
            this.emplRoleMapper.save(new EmplRole(empl.getEmplId(), roleId));
        }

        return Response.success("修改成功！");
    }

    /**
     * 逻辑删除
     *
     * @param emplId ： 员工的ID
     * @return
     */
    @Override
    public ResultDTO deleteFalse(Integer emplId) {
        // 内置的超级管理员不能删除
        if (emplId.equals(1)){
            return Response.error(1001, "内置超级管理员不能删除！");
        }
        // 删除员工的数据
        this.emplMapper.deleteFalse(emplId);
        // 删除关系表的数据
        this.emplRoleMapper.deleteByEmplId(emplId);

        return Response.success("删除成功！");
    }


    /**
     * 批量逻辑删除
     *
     * @param ids ： 员工的id数组
     * @return
     */
    @Override
    @Transactional(rollbackFor = Throwable.class)
    public ResultDTO deleteAll(Integer[] ids) {
        // 判断是勾选了内置超级管理员
        // 先转换成集合
        List<Integer> list = Arrays.asList(ids);
        if (list.contains(1)){
            return Response.error(1001, "内置超级管理员不能删除！");
        }
        // 直接删除
        this.emplMapper.deleteAll(ids);
        // 删除关系表的数据
        this.emplRoleMapper.deleteAllByEmplId(ids);

        return Response.success("删除成功！");
    }

    @Override
    public Integer findIdByName(String emplName) {
        return emplMapper.findIdByName(emplName);
    }
}
